home *** CD-ROM | disk | FTP | other *** search
/ Aminet 21 / Aminet 21 (1997)(GTI - Schatztruhe)[!][Oct 1997].iso / Aminet / gfx / show / gs_src_gs.lha / gs5.03 / sfxstdio.c < prev    next >
C/C++ Source or Header  |  1997-03-29  |  7KB  |  242 lines
  1. /* Copyright (C) 1993, 1995, 1996, 1997 Aladdin Enterprises.  All rights reserved.
  2.   
  3.   This file is part of Aladdin Ghostscript.
  4.   
  5.   Aladdin Ghostscript is distributed with NO WARRANTY OF ANY KIND.  No author
  6.   or distributor accepts any responsibility for the consequences of using it,
  7.   or for whether it serves any particular purpose or works at all, unless he
  8.   or she says so in writing.  Refer to the Aladdin Ghostscript Free Public
  9.   License (the "License") for full details.
  10.   
  11.   Every copy of Aladdin Ghostscript must include a copy of the License,
  12.   normally in a plain ASCII text file named PUBLIC.  The License grants you
  13.   the right to copy, modify and redistribute Aladdin Ghostscript, but only
  14.   under certain conditions described in the License.  Among other things, the
  15.   License requires that the copyright notice and this notice be preserved on
  16.   all copies.
  17. */
  18.  
  19. /* sfxstdio.c */
  20. /* File stream implementation using stdio */
  21. #include "stdio_.h"        /* includes std.h */
  22. #include "memory_.h"
  23. #include "gdebug.h"
  24. #include "gpcheck.h"
  25. #include "stream.h"
  26. #include "strimpl.h"
  27.  
  28. /* Forward references for file stream procedures */
  29. private int
  30.   s_file_available(P2(stream *, long *)),
  31.   s_file_read_seek(P2(stream *, long)),
  32.   s_file_read_close(P1(stream *)),
  33.   s_file_read_process(P4(stream_state *, stream_cursor_read *,
  34.     stream_cursor_write *, bool));
  35. private int
  36.   s_file_write_seek(P2(stream *, long)),
  37.   s_file_write_flush(P1(stream *)),
  38.   s_file_write_close(P1(stream *)),
  39.   s_file_write_process(P4(stream_state *, stream_cursor_read *,
  40.     stream_cursor_write *, bool));
  41. private int
  42.   s_file_switch(P2(stream *, bool));
  43.  
  44. /* ------ File streams ------ */
  45.  
  46. /* Initialize a stream for reading an OS file. */
  47. void
  48. sread_file(register stream *s, FILE *file, byte *buf, uint len)
  49. {    static const stream_procs p =
  50.        {    s_file_available, s_file_read_seek, s_std_read_reset,
  51.         s_std_read_flush, s_file_read_close, s_file_read_process,
  52.         s_file_switch
  53.        };
  54.     /*
  55.      * There is no really portable way to test seekability,
  56.      * but this should work on most systems.
  57.      * Note that if our probe sets the ferror bit for the stream,
  58.      * we have to clear it again to avoid trouble later.
  59.      */
  60.     int had_error = ferror(file);
  61.     long curpos = ftell(file);
  62.     bool seekable = (curpos != -1L && fseek(file, curpos, SEEK_SET) == 0);
  63.  
  64.     if ( !had_error )
  65.       clearerr(file);
  66.     s_std_init(s, buf, len, &p,
  67.            (seekable ? s_mode_read + s_mode_seek : s_mode_read));
  68.     if_debug1('s', "[s]read file=0x%lx\n", (ulong)file);
  69.     s->file = file;
  70.     s->file_modes = s->modes;
  71. }
  72. /* Procedures for reading from a file */
  73. private int
  74. s_file_available(register stream *s, long *pl)
  75. {    *pl = sbufavailable(s);
  76.     if ( sseekable(s) )
  77.        {    long pos, end;
  78.         pos = ftell(s->file);
  79.         if ( fseek(s->file, 0L, SEEK_END) ) return ERRC;
  80.         end = ftell(s->file);
  81.         if ( fseek(s->file, pos, SEEK_SET) ) return ERRC;
  82.         *pl += end - pos;
  83.         if ( *pl == 0 ) *pl = -1;    /* EOF */
  84.        }
  85.     else
  86.        {    if ( *pl == 0 && feof(s->file) ) *pl = -1;    /* EOF */
  87.        }
  88.     return 0;
  89. }
  90. private int
  91. s_file_read_seek(register stream *s, long pos)
  92. {    uint end = s->srlimit - s->cbuf + 1;
  93.     long offset = pos - s->position;
  94.     if ( offset >= 0 && offset <= end )
  95.        {    /* Staying within the same buffer */
  96.         s->srptr = s->cbuf + offset - 1;
  97.         return 0;
  98.        }
  99.     if ( fseek(s->file, pos, SEEK_SET) != 0 )
  100.         return ERRC;
  101.     s->srptr = s->srlimit = s->cbuf - 1;
  102.     s->end_status = 0;
  103.     s->position = pos;
  104.     return 0;
  105. }
  106. private int
  107. s_file_read_close(stream *s)
  108. {    FILE *file = s->file;
  109.     if ( file != 0 )
  110.       {    s->file = 0;
  111.         return fclose(file);
  112.       }
  113.     return 0;
  114. }
  115.  
  116. /* Initialize a stream for writing an OS file. */
  117. void
  118. swrite_file(register stream *s, FILE *file, byte *buf, uint len)
  119. {    static const stream_procs p =
  120.        {    s_std_noavailable, s_file_write_seek, s_std_write_reset,
  121.         s_file_write_flush, s_file_write_close, s_file_write_process,
  122.         s_file_switch
  123.        };
  124.     s_std_init(s, buf, len, &p,
  125.            (file == stdout ? s_mode_write : s_mode_write + s_mode_seek));
  126.     if_debug1('s', "[s]write file=0x%lx\n", (ulong)file);
  127.     s->file = file;
  128.     s->file_modes = s->modes;
  129. }
  130. /* Initialize for appending to an OS file. */
  131. void
  132. sappend_file(register stream *s, FILE *file, byte *buf, uint len)
  133. {    swrite_file(s, file, buf, len);
  134.     s->modes = s_mode_write + s_mode_append;    /* no seek */
  135.     s->file_modes = s->modes;
  136.     fseek(file, 0L, SEEK_END);
  137.     s->position = ftell(file);
  138. }
  139. /* Procedures for writing on a file */
  140. private int
  141. s_file_write_seek(stream *s, long pos)
  142. {    /* We must flush the buffer to reposition. */
  143.     int code = sflush(s);
  144.     if ( code < 0 )
  145.         return code;
  146.     if ( fseek(s->file, pos, SEEK_SET) != 0 )
  147.         return ERRC;
  148.     s->position = pos;
  149.     return 0;
  150. }
  151. private int
  152. s_file_write_flush(register stream *s)
  153. {    int result = s_process_write_buf(s, false);
  154.     fflush(s->file);
  155.     return result;
  156. }
  157. private int
  158. s_file_write_close(register stream *s)
  159. {    s_process_write_buf(s, true);
  160.     return s_file_read_close(s);
  161. }
  162.  
  163. #define ss ((stream *)st)
  164.  
  165. /* Process a buffer for a file reading stream. */
  166. /* This is the first stream in the pipeline, so pr is irrelevant. */
  167. private int
  168. s_file_read_process(stream_state *st, stream_cursor_read *ignore_pr,
  169.   stream_cursor_write *pw, bool last)
  170. {    FILE *file = ss->file;
  171.     int count = fread(pw->ptr + 1, 1, (uint)(pw->limit - pw->ptr), file);
  172.     if ( count < 0 )
  173.         count = 0;
  174.     pw->ptr += count;
  175.     process_interrupts();
  176.     return (ferror(file) ? ERRC : feof(file) ? EOFC : 1);
  177. }
  178.  
  179. /* Process a buffer for a file writing stream. */
  180. /* This is the last stream in the pipeline, so pw is irrelevant. */
  181. private int
  182. s_file_write_process(stream_state *st, stream_cursor_read *pr,
  183.   stream_cursor_write *ignore_pw, bool last)
  184. {    /* The DEC C library on AXP architectures gives an error on */
  185.     /* fwrite if the count is zero! */
  186.     uint count = pr->limit - pr->ptr;
  187.     if ( count != 0 )
  188.       {    FILE *file = ss->file;
  189.         int written = fwrite(pr->ptr + 1, 1, count, file);
  190.         if ( written < 0 )
  191.           written = 0;
  192.         pr->ptr += written;
  193.         process_interrupts();
  194.         return (ferror(file) ? ERRC : 0);
  195.       }
  196.     else
  197.       {    process_interrupts();
  198.         return 0;
  199.       }
  200. }
  201.  
  202. #undef ss
  203.  
  204. /* Switch a file stream to reading or writing. */
  205. private int
  206. s_file_switch(stream *s, bool writing)
  207. {    uint modes = s->file_modes;
  208.     FILE *file = s->file;
  209.     long pos;
  210.     if ( writing )
  211.       {    if ( !(s->file_modes & s_mode_write) )
  212.           return ERRC;
  213.         pos = stell(s);
  214.         if_debug2('s', "[s]switch 0x%lx to write at %ld\n",
  215.               (ulong)s, pos);
  216.         fseek(file, pos, SEEK_SET);
  217.         if ( modes & s_mode_append )
  218.           {    sappend_file(s, file, s->cbuf, s->cbsize);    /* sets position */
  219.           }
  220.         else
  221.           {    swrite_file(s, file, s->cbuf, s->cbsize);
  222.             s->position = pos;
  223.           }
  224.         s->modes = modes;
  225.       }
  226.     else
  227.       {    if ( !(s->file_modes & s_mode_read) )
  228.           return ERRC;
  229.         pos = stell(s);
  230.         if_debug2('s', "[s]switch 0x%lx to read at %ld\n",
  231.               (ulong)s, pos);
  232.         if ( sflush(s) < 0 )
  233.           return ERRC;
  234.         fseek(file, 0L, SEEK_CUR);        /* pacify C library */
  235.         sread_file(s, file, s->cbuf, s->cbsize);
  236.         s->modes |= modes & s_mode_append;    /* don't lose append info */
  237.         s->position = pos;
  238.       }
  239.     s->file_modes = modes;
  240.     return 0;
  241. }
  242.